'use strict';

exports.main = async (event, context) => {
	try {
		const db = uniCloud.database();
		const collection = db.collection('data');
		
		// 获取查询参数
		const { queryType = 'getLatest', limit = 100, skip = 0, startTime, endTime, targetDate, node_id } = event;
		
		let query = collection;
		
		// 如果指定了node_id，添加筛选条件
		if (node_id !== undefined && node_id !== null && node_id !== '') {
			query = query.where({
				node_id: parseInt(node_id)
			});
		}
		
		let result;
		let totalCount = 0;
		
		switch (queryType) {
			case 'getLatest':
				// 获取总数据量
				const countResult = await collection.count();
				totalCount = countResult.total;
				
				// 获取最新数据
				result = await query
					.orderBy('timestamp', 'desc')
					.skip(skip)
					.limit(limit)
					.get();
				break;
				
			case 'getByTimeRange':
				// 按时间范围查询
				if (!startTime || !endTime) {
					return {
						code: -1,
						message: '时间范围查询需要提供开始时间和结束时间'
					};
				}
				
				const startTimestamp = new Date(startTime).getTime();
				const endTimestamp = new Date(endTime).getTime();
				
				result = await query
					.where({
						timestamp: db.command.gte(startTimestamp).and(db.command.lte(endTimestamp))
					})
					.orderBy('timestamp', 'desc')
					.limit(limit)
					.get();
				break;
				
			case 'getRecentDay':
				// 获取最近一天的数据
				const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000; // 24小时前的时间戳
				
				result = await query
					.where({
						timestamp: db.command.gte(oneDayAgo)
					})
					.orderBy('timestamp', 'asc') // 按时间升序排列，便于绘图
					.limit(1000) // 增加数据获取限制，支持更多数据点
					.get();
				break;
				
			case 'getByDate':
				// 按指定日期查询数据
				if (!targetDate) {
					return {
						code: -1,
						message: '按日期查询需要提供目标日期参数 targetDate'
					};
				}
				
				// 解析目标日期，获取当天的开始和结束时间戳
				const targetDateObj = new Date(targetDate);
				if (isNaN(targetDateObj.getTime())) {
					return {
						code: -1,
						message: '无效的日期格式，请使用 YYYY-MM-DD 格式'
					};
				}
				
				// 设置为当天的开始时间 (00:00:00)
				targetDateObj.setHours(0, 0, 0, 0);
				const dayStartTimestamp = targetDateObj.getTime();
				
				// 设置为当天的结束时间 (23:59:59.999)
				targetDateObj.setHours(23, 59, 59, 999);
				const dayEndTimestamp = targetDateObj.getTime();
				
				result = await query
					.where({
						timestamp: db.command.gte(dayStartTimestamp).and(db.command.lte(dayEndTimestamp))
					})
					.orderBy('timestamp', 'asc') // 按时间升序排列，便于绘图
					.limit(1000) // 限制数据获取数量
					.get();
				break;
				
			default:
				return {
					code: -1,
					message: '不支持的查询类型'
				};
		}
		
		// 计算统计信息
		const dataList = result.data;
		let statistics = null;
		
		if (dataList.length > 0) {
			statistics = {
				temperature: calculateStats(dataList, 'temperature'),
				humidity: calculateStats(dataList, 'humidity'),
				uv: calculateStats(dataList, 'uv'),
				ph: calculateStats(dataList, 'ph'),
				soil: calculateStats(dataList, 'soil'),
				rain: calculateStats(dataList, 'rain'),
				light: calculateStats(dataList, 'light')
			};
		}
		
		return {
			code: 0,
			message: '查询成功',
			data: {
				dataList: dataList,
				statistics: statistics,
				total: totalCount > 0 ? totalCount : dataList.length
			}
		};
		
	} catch (error) {
		console.error('查询数据失败:', error);
		return {
			code: -1,
			message: '查询数据失败',
			error: error.message
		};
	}
};

// 计算统计信息的辅助函数
function calculateStats(dataList, field) {
	const values = dataList.map(item => parseFloat(item[field]) || 0);
	const latest = values[values.length - 1] || 0;
	const min = Math.min(...values);
	const max = Math.max(...values);
	const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
	
	return {
		latest: parseFloat(latest.toFixed(1)),
		min: parseFloat(min.toFixed(1)),
		max: parseFloat(max.toFixed(1)),
		avg: parseFloat(avg.toFixed(1))
	};
}